home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 January: Mac OS SDK / Dev.CD Jan 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / PInterfaces / FSM.p < prev    next >
Encoding:
Text File  |  1997-08-12  |  33.8 KB  |  889 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        FSM.p
  3.  
  4.      Contains:    HFS External File System Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0.1
  8.  
  9.      Copyright:    © 1985-1997 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT FSM;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __FSM__}
  28. {$SETC __FSM__ := 1}
  29.  
  30. {$I+}
  31. {$SETC FSMIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __FILES__}
  35. {$I Files.p}
  36. {$ENDC}
  37.  
  38.  
  39. {$PUSH}
  40. {$ALIGN MAC68K}
  41. {$LibExport+}
  42.  
  43. { VolMount declarations are now in Files.≈ }
  44.  
  45. {
  46.  * Miscellaneous file system values not in Files.≈
  47.  }
  48.  
  49. CONST
  50.     fsUsrCNID                    = 16;                            {  First assignable directory or file number  }
  51.                                                                 {     File system trap word attribute bits  }
  52.     kHFSBit                        = 9;                            {  HFS call: bit 9  }
  53.     kHFSMask                    = $0200;
  54.     kAsyncBit                    = 10;                            {  Asynchronous call: bit 10  }
  55.     kAsyncMask                    = $0400;
  56.  
  57.  
  58. {
  59.  * HFSCIProc selectCode values
  60.  * Note: The trap attribute bits (the HFS bit and the asynchronous bit)
  61.  * may be set in these selectCode values.
  62.  }
  63.     kFSMOpen                    = $A000;
  64.     kFSMClose                    = $A001;
  65.     kFSMRead                    = $A002;
  66.     kFSMWrite                    = $A003;
  67.     kFSMGetVolInfo                = $A007;
  68.     kFSMCreate                    = $A008;
  69.     kFSMDelete                    = $A009;
  70.     kFSMOpenRF                    = $A00A;
  71.     kFSMRename                    = $A00B;
  72.     kFSMGetFileInfo                = $A00C;
  73.     kFSMSetFileInfo                = $A00D;
  74.     kFSMUnmountVol                = $A00E;
  75.     kFSMMountVol                = $A00F;
  76.     kFSMAllocate                = $A010;
  77.     kFSMGetEOF                    = $A011;
  78.     kFSMSetEOF                    = $A012;
  79.     kFSMFlushVol                = $A013;
  80.     kFSMGetVol                    = $A014;
  81.     kFSMSetVol                    = $A015;
  82.     kFSMEject                    = $A017;
  83.     kFSMGetFPos                    = $A018;
  84.     kFSMOffline                    = $A035;
  85.     kFSMSetFilLock                = $A041;
  86.     kFSMRstFilLock                = $A042;
  87.     kFSMSetFilType                = $A043;
  88.     kFSMSetFPos                    = $A044;
  89.     kFSMFlushFile                = $A045;                        {     The File System HFSDispatch selectCodes  }
  90.     kFSMOpenWD                    = $0001;
  91.     kFSMCloseWD                    = $0002;
  92.     kFSMCatMove                    = $0005;
  93.     kFSMDirCreate                = $0006;
  94.     kFSMGetWDInfo                = $0007;
  95.     kFSMGetFCBInfo                = $0008;
  96.     kFSMGetCatInfo                = $0009;
  97.     kFSMSetCatInfo                = $000A;
  98.     kFSMSetVolInfo                = $000B;
  99.     kFSMLockRng                    = $0010;
  100.     kFSMUnlockRng                = $0011;
  101.     kFSMXGetVolInfo                = $0012;
  102.     kFSMCreateFileIDRef            = $0014;
  103.     kFSMDeleteFileIDRef            = $0015;
  104.     kFSMResolveFileIDRef        = $0016;
  105.     kFSMExchangeFiles            = $0017;
  106.     kFSMCatSearch                = $0018;
  107.     kFSMOpenDF                    = $001A;
  108.     kFSMMakeFSSpec                = $001B;                        {     The Desktop Manager HFSDispatch selectCodes  }
  109.     kFSMDTGetPath                = $0020;
  110.     kFSMDTCloseDown                = $0021;
  111.     kFSMDTAddIcon                = $0022;
  112.     kFSMDTGetIcon                = $0023;
  113.     kFSMDTGetIconInfo            = $0024;
  114.     kFSMDTAddAPPL                = $0025;
  115.     kFSMDTRemoveAPPL            = $0026;
  116.     kFSMDTGetAPPL                = $0027;
  117.     kFSMDTSetComment            = $0028;
  118.     kFSMDTRemoveComment            = $0029;
  119.     kFSMDTGetComment            = $002A;
  120.     kFSMDTFlush                    = $002B;
  121.     kFSMDTReset                    = $002C;
  122.     kFSMDTGetInfo                = $002D;
  123.     kFSMDTOpenInform            = $002E;
  124.     kFSMDTDelete                = $002F;                        {     The AppleShare HFSDispatch selectCodes  }
  125.     kFSMGetVolParms                = $0030;
  126.     kFSMGetLogInInfo            = $0031;
  127.     kFSMGetDirAccess            = $0032;
  128.     kFSMSetDirAccess            = $0033;
  129.     kFSMMapID                    = $0034;
  130.     kFSMMapName                    = $0035;
  131.     kFSMCopyFile                = $0036;
  132.     kFSMMoveRename                = $0037;
  133.     kFSMOpenDeny                = $0038;
  134.     kFSMOpenRFDeny                = $0039;
  135.     kFSMGetXCatInfo                = $003A;
  136.     kFSMGetVolMountInfoSize        = $003F;
  137.     kFSMGetVolMountInfo            = $0040;
  138.     kFSMVolumeMount                = $0041;
  139.     kFSMShare                    = $0042;
  140.     kFSMUnShare                    = $0043;
  141.     kFSMGetUGEntry                = $0044;
  142.     kFSMGetForeignPrivs            = $0060;
  143.     kFSMSetForeignPrivs            = $0061;
  144.  
  145. {
  146.  * UTDetermineVol status values
  147.  }
  148.     dtmvError                    = 0;                            {  param error  }
  149.     dtmvFullPathame                = 1;                            {  determined by full pathname  }
  150.     dtmvVRefNum                    = 2;                            {  determined by volume refNum  }
  151.     dtmvWDRefNum                = 3;                            {  determined by working directory refNum  }
  152.     dtmvDriveNum                = 4;                            {  determined by drive number  }
  153.     dtmvDefault                    = 5;                            {  determined by default volume  }
  154.  
  155.  
  156. {
  157.  * UTGetBlock options
  158.  }
  159.     gbDefault                    = 0;                            {  default value - read if not found  }
  160.                                                                 {     bits and masks  }
  161.     gbReadBit                    = 0;                            {  read block from disk (forced read)  }
  162.     gbReadMask                    = $0001;
  163.     gbExistBit                    = 1;                            {  get existing cache block  }
  164.     gbExistMask                    = $0002;
  165.     gbNoReadBit                    = 2;                            {  don't read block from disk if not found in cache  }
  166.     gbNoReadMask                = $0004;
  167.     gbReleaseBit                = 3;                            {  release block immediately after GetBlock  }
  168.     gbReleaseMask                = $0008;
  169.  
  170.  
  171. {
  172.  * UTReleaseBlock options
  173.  }
  174.     rbDefault                    = 0;                            {  default value - just mark the buffer not in-use  }
  175.                                                                 {     bits and masks  }
  176.     rbWriteBit                    = 0;                            {  force write buffer to disk  }
  177.     rbWriteMask                    = $0001;
  178.     rbTrashBit                    = 1;                            {  trash buffer contents after release  }
  179.     rbTrashMask                    = $0002;
  180.     rbDirtyBit                    = 2;                            {  mark buffer dirty  }
  181.     rbDirtyMask                    = $0004;
  182.     rbFreeBit                    = 3;                            {  free the buffer (save in the hash)  }
  183.     rbFreeMask                    = $000A;                        {  rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache; on >= System 7.0, rbfreeMask overrides rbTrash  }
  184.  
  185.  
  186. {
  187.  * UTFlushCache options
  188.  }
  189.     fcDefault                    = 0;                            {  default value - pass this fcOption to just flush any dirty buffers  }
  190.                                                                 {     bits and masks  }
  191.     fcTrashBit                    = 0;                            {  (don't pass this as fcOption, use only for testing bit)  }
  192.     fcTrashMask                    = $0001;                        {  pass this fcOption value to flush and trash cache blocks  }
  193.     fcFreeBit                    = 1;                            {  (don't pass this as fcOption, use only for testing bit)  }
  194.     fcFreeMask                    = $0003;                        {  pass this fcOption to flush and free cache blocks (Note: both fcTrash and fcFree bits are set)  }
  195.  
  196.  
  197. {
  198.  * UTCacheReadIP and UTCacheWriteIP cacheOption
  199.  }
  200.     noCacheBit                    = 5;                            {  don't cache this please  }
  201.     noCacheMask                    = $0020;
  202.     rdVerifyBit                    = 6;                            {  read verify  }
  203.     rdVerifyMask                = $0040;
  204.  
  205.  
  206. {
  207.  * Cache routine internal error codes
  208.  }
  209.     chNoBuf                        = 1;                            {  no free cache buffers (all in use)  }
  210.     chInUse                        = 2;                            {  requested block in use  }
  211.     chnotfound                    = 3;                            {  requested block not found  }
  212.     chNotInUse                    = 4;                            {  block being released was not in use  }
  213.  
  214.  
  215. {
  216.  * FCBRec.fcbFlags bits
  217.  }
  218.     fcbWriteBit                    = 0;                            {  Data can be written to this file  }
  219.     fcbWriteMask                = $01;
  220.     fcbResourceBit                = 1;                            {  This file is a resource fork  }
  221.     fcbResourceMask                = $02;
  222.     fcbWriteLockedBit            = 2;                            {  File has a locked byte range  }
  223.     fcbWriteLockedMask            = $04;
  224.     fcbSharedWriteBit            = 4;                            {  File is open for shared write access  }
  225.     fcbSharedWriteMask            = $10;
  226.     fcbFileLockedBit            = 5;                            {  File is locked (write-protected)  }
  227.     fcbFileLockedMask            = $20;
  228.     fcbOwnClumpBit                = 6;                            {  File has clump size specified in FCB  }
  229.     fcbOwnClumpMask                = $40;
  230.     fcbModifiedBit                = 7;                            {  File has changed since it was last flushed  }
  231.     fcbModifiedMask                = $80;
  232.  
  233.  
  234. {
  235.  * ExtFileProc options
  236.  }
  237.     extendFileAllBit            = 0;                            {  allocate all requested bytes or none  }
  238.     extendFileAllMask            = $0001;
  239.     extendFileContigBit            = 1;                            {  force contiguous allocation  }
  240.     extendFileContigMask        = $0002;
  241.  
  242.  
  243. {
  244.  *    HFS Component Interface constants
  245.  }
  246.  
  247. {
  248.  * compInterfMask bits specific to HFS component
  249.  }
  250.     hfsCIDoesHFSBit                = 23;                            {  set if file system supports HFS calls  }
  251.     hfsCIDoesHFSMask            = $00800000;
  252.     hfsCIDoesAppleShareBit        = 22;                            {  set if AppleShare calls supported  }
  253.     hfsCIDoesAppleShareMask        = $00400000;
  254.     hfsCIDoesDeskTopBit            = 21;                            {  set if Desktop Database calls supported  }
  255.     hfsCIDoesDeskTopMask        = $00200000;
  256.     hfsCIDoesDynamicLoadBit        = 20;                            {  set if dynamically loading code resource  }
  257.     hfsCIDoesDynamicLoadMask    = $00100000;                    {         supported  }
  258.     hfsCIResourceLoadedBit        = 19;                            {  set if code resource already loaded  }
  259.     hfsCIResourceLoadedMask        = $00080000;
  260.     hfsCIHasHLL2PProcBit        = 18;                            {  set if FFS' log2PhyProc and Extendfile proc  }
  261.     hfsCIHasHLL2PProcMask        = $00040000;                    {  is written in a high level language. (i.e., uses Pascal calling convention)  }
  262.     hfsCIWantsDTSupportBit        = 17;                            {  set if FFS wants the Mac OS's Desktop Manager code to handle  }
  263.     hfsCIWantsDTSupportMask        = $00020000;                    {  all Desktop Manager requests to its volumes.  }
  264.  
  265.  
  266. {
  267.  *    Disk Initialization Component Interface constants
  268.  }
  269.  
  270. {
  271.  * compInterfMask bits specific to Disk Initialization component
  272.  }
  273.     diCIHasExtFormatParamsBit    = 18;                            {  set if file system needs extended format  }
  274.     diCIHasExtFormatParamsMask    = $00040000;                    {         parameters  }
  275.     diCIHasMultiVolTypesBit        = 17;                            {  set if file system supports more than one  }
  276.     diCIHasMultiVolTypesMask    = $00020000;                    {         volume type  }
  277.     diCIDoesSparingBit            = 16;                            {  set if file system supports disk sparing  }
  278.     diCIDoesSparingMask            = $00010000;
  279.     diCILiveBit                    = 0;                            {  set if file system is candidate for current  }
  280.     diCILiveMask                = $00000001;                    {         formatting operation (set by PACK2)  }
  281.  
  282.  
  283. {
  284.  * Disk Initialization Component Function selectors
  285.  }
  286.     diCILoad                    = 1;                            {  Make initialization code memory resident  }
  287.     diCIUnload                    = 2;                            {  Make initialization code purgeable  }
  288.     diCIEvaluateSizeChoices        = 3;                            {  Evaluate size choices  }
  289.     diCIExtendedZero            = 4;                            {  Write an empty volume directory  }
  290.     diCIValidateVolName            = 5;                            {  Validate volume name  }
  291.     diCIGetVolTypeInfo            = 6;                            {  get volume type info  }
  292.     diCIGetFormatString            = 7;                            {  get dialog format string  }
  293.     diCIGetExtFormatParams        = 8;                            {  get extended format parameters  }
  294.     diCIGetDefectList            = 9;                            {  return the defect list for the indicated disk - reserved for future use  }
  295.  
  296.  
  297. {
  298.  * Constants used in the DICIEvaluateSizeRec and FormatListRec
  299.  }
  300.     diCIFmtListMax                = 8;                            {  maximum number of format list entries in DICIEvaluateSizeRec.numSizeEntries  }
  301.                                                                 {     bits in FormatListRec.formatFlags:  }
  302.     diCIFmtFlagsValidBit        = 7;                            {  set if sec, side, tracks valid  }
  303.     diCIFmtFlagsValidMask        = $80;
  304.     diCIFmtFlagsCurrentBit        = 6;                            {  set if current disk has this fmt  }
  305.     diCIFmtFlagsCurrentMask        = $40;                            {     bits in FormatListRec.sizeListFlags:  }
  306.     diCISizeListOKBit            = 15;                            {  set if this disk size usable  }
  307.     diCISizeListOKMask            = $8000;
  308.  
  309.  
  310. {
  311.  * DICIGetFormatStringRec.stringKind format strings
  312.  }
  313.     diCIAlternateFormatStr        = 1;                            {  get alternate format  string (Balloon Help)  }
  314.     diCISizePresentationStr        = 2;                            {  get size presentation string (for dialog)  }
  315.  
  316.  
  317. {
  318.  * Error codes returned by Disk Sparing
  319.  }
  320.     diCIUserCancelErr            = 1;                            {  user cancelled the disk init  }
  321.     diCICriticalSectorBadErr    = 20;                            {  critical sectors are bad (hopeless)     }
  322.     diCISparingFailedErr        = 21;                            {  disk cannot be spared  }
  323.     diCITooManyBadSectorsErr    = 22;                            {  too many bad sectors  }
  324.     diCIUnknownVolTypeErr        = 23;                            {  the volume type passed in diCIExtendedZero paramBlock is not supported  }
  325.     diCIVolSizeMismatchErr        = 24;                            {  specified volume size doesn’t match with formatted disk size  }
  326.     diCIUnknownDICallErr        = 25;                            {  bogus DI function call selector  }
  327.     diCINoSparingErr            = 26;                            {  disk is bad but the target FS doesn't do disk sparing  }
  328.     diCINoExtendInfoErr            = 27;                            {  missing file system specific extra parameter in diCIExtendedZero call  }
  329.     diCINoMessageTextErr        = 28;                            {  missing message text in DIReformat call  }
  330.  
  331.  
  332. {
  333.  *    File System Manager constants
  334.  }
  335.  
  336. {
  337.  * Miscellaneous constants used by FSM
  338.  }
  339.     fsdVersion1                    = 1;                            {  current version of FSD record  }
  340.     fsmIgnoreFSID                = $FFFE;                        {  this FSID should be ignored by the driver  }
  341.     fsmGenericFSID                = $FFFF;                        {  unknown foreign file system ID  }
  342.  
  343.  
  344. {
  345.  * compInterfMask bits common to all FSM components
  346.  }
  347.     fsmComponentEnableBit        = 31;                            {  set if FSM component interface is enabled  }
  348.     fsmComponentEnableMask        = $80000000;
  349.     fsmComponentBusyBit            = 30;                            {  set if FSM component interface is busy  }
  350.     fsmComponentBusyMask        = $40000000;
  351.  
  352.  
  353. {
  354.  * Selectors for GetFSInfo
  355.  }
  356.     fsmGetFSInfoByIndex            = -1;                            {  get fs info by index  }
  357.     fsmGetFSInfoByFSID            = 0;                            {  get fs info by FSID  }
  358.     fsmGetFSInfoByRefNum        = 1;                            {  get fs info by file/vol refnum  }
  359.  
  360.  
  361. {
  362.  * InformFSM messages
  363.  }
  364.     fsmNopMessage                = 0;                            {  nop  }
  365.     fsmDrvQElChangedMessage        = 1;                            {  DQE has changed  }
  366.     fsmGetFSIconMessage            = 2;                            {  Get FFS's disk icon  }
  367.  
  368.  
  369. {
  370.  * Messages passed to the fileSystemCommProc
  371.  }
  372.     ffsNopMessage                = 0;                            {  nop, should always return noErr  }
  373.     ffsGetIconMessage            = 1;                            {  return disk icon and mask  }
  374.     ffsIDDiskMessage            = 2;                            {  identify the about-to-be-mounted volume  }
  375.     ffsLoadMessage                = 3;                            {  load in the FFS  }
  376.     ffsUnloadMessage            = 4;                            {  unload the FFS  }
  377.     ffsIDVolMountMessage        = 5;                            {  identify a VolMountInfo record  }
  378.     ffsInformMessage            = 6;                            {  FFS defined message  }
  379.     ffsGetIconInfoMessage        = 7;
  380.  
  381.  
  382. {
  383.  * Error codes from FSM functions
  384.  }
  385.     fsmFFSNotFoundErr            = -431;                            {  Foreign File system does not exist - new Pack2 could return this error too  }
  386.     fsmBusyFFSErr                = -432;                            {  File system is busy, cannot be removed  }
  387.     fsmBadFFSNameErr            = -433;                            {  Name length not 1 <= length <= 31  }
  388.     fsmBadFSDLenErr                = -434;                            {  FSD size incompatible with current FSM vers  }
  389.     fsmDuplicateFSIDErr            = -435;                            {  FSID already exists on InstallFS  }
  390.     fsmBadFSDVersionErr            = -436;                            {  FSM version incompatible with FSD  }
  391.     fsmNoAlternateStackErr        = -437;                            {  no alternate stack for HFS CI  }
  392.     fsmUnknownFSMMessageErr        = -438;                            {  unknown message passed to FSM  }
  393.  
  394.  
  395. {
  396.  *    HFS Utility routine records
  397.  }
  398.  
  399. {
  400.  * record used by UTGetPathComponentName
  401.  }
  402.  
  403. TYPE
  404.     ParsePathRecPtr = ^ParsePathRec;
  405.     ParsePathRec = RECORD
  406.         namePtr:                StringPtr;                                {  pathname to parse  }
  407.         startOffset:            INTEGER;                                {  where to start parsing  }
  408.         componentLength:        INTEGER;                                {  the length of the pathname component parsed  }
  409.         moreName:                SignedByte;                                {  non-zero if there are more components after this one  }
  410.         foundDelimiter:            SignedByte;                                {  non-zero if parsing stopped because a colon (:) delimiter was found  }
  411.     END;
  412.  
  413.     WDCBRecPtr = ^WDCBRec;
  414.     WDCBRec = RECORD
  415.         wdVCBPtr:                VCBPtr;                                    {  Pointer to VCB of this working directory  }
  416.         wdDirID:                LONGINT;                                {  Directory ID number of this working directory  }
  417.         wdCatHint:                LONGINT;                                {  Hint for finding this working directory  }
  418.         wdProcID:                LONGINT;                                {  Process that created this working directory  }
  419.     END;
  420.  
  421.     FCBRecPtr = ^FCBRec;
  422.     FCBRec = RECORD
  423.         fcbFlNm:                LONGINT;                                {  FCB file number. Non-zero marks FCB used  }
  424.         fcbFlags:                SignedByte;                                {  FCB flags  }
  425.         fcbTypByt:                SignedByte;                                {  File type byte  }
  426.         fcbSBlk:                INTEGER;                                {  File start block (in alloc size blks)  }
  427.         fcbEOF:                    LONGINT;                                {  Logical length or EOF in bytes  }
  428.         fcbPLen:                LONGINT;                                {  Physical file length in bytes  }
  429.         fcbCrPs:                LONGINT;                                {  Current position within file  }
  430.         fcbVPtr:                VCBPtr;                                    {  Pointer to the corresponding VCB  }
  431.         fcbBfAdr:                Ptr;                                    {  File's buffer address  }
  432.         fcbFlPos:                INTEGER;                                {  Directory block this file is in  }
  433.                                                                         {  FCB Extensions for HFS  }
  434.         fcbClmpSize:            LONGINT;                                {  Number of bytes per clump  }
  435.         fcbBTCBPtr:                Ptr;                                    {  Pointer to B*-Tree control block for file  }
  436.         fcbExtRec:                ARRAY [0..2] OF LONGINT;                {  First 3 file extents  }
  437.         fcbFType:                OSType;                                    {  File's 4 Finder Type bytes  }
  438.         fcbCatPos:                LONGINT;                                {  Catalog hint for use on Close  }
  439.         fcbDirID:                LONGINT;                                {  Parent Directory ID  }
  440.         fcbCName:                Str31;                                    {  CName of open file  }
  441.     END;
  442.  
  443. {
  444.  *    HFS Component Interface records
  445.  }
  446.     Lg2PhysProcPtr = ProcPtr;  { FUNCTION Lg2Phys(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT): OSErr; }
  447.  
  448.     Lg2PhysUPP = UniversalProcPtr;
  449.  
  450. CONST
  451.     uppLg2PhysProcInfo = $003FEFE0;
  452.  
  453. FUNCTION NewLg2PhysProc(userRoutine: Lg2PhysProcPtr): Lg2PhysUPP;
  454.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  455.     INLINE $2E9F;
  456.     {$ENDC}
  457.  
  458. FUNCTION CallLg2PhysProc(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT; userRoutine: Lg2PhysUPP): OSErr;
  459.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  460.     INLINE $205F, $4E90;
  461.     {$ENDC}
  462.  
  463. TYPE
  464.     HFSCIProcPtr = ProcPtr;  { FUNCTION HFSCI(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER): OSErr; }
  465.  
  466.     HFSCIUPP = UniversalProcPtr;
  467.  
  468. CONST
  469.     uppHFSCIProcInfo = $0000BEE0;
  470.  
  471. FUNCTION NewHFSCIProc(userRoutine: HFSCIProcPtr): HFSCIUPP;
  472.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  473.     INLINE $2E9F;
  474.     {$ENDC}
  475.  
  476. FUNCTION CallHFSCIProc(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER; userRoutine: HFSCIUPP): OSErr;
  477.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  478.     INLINE $205F, $4E90;
  479.     {$ENDC}
  480.  
  481. TYPE
  482.     HFSCIRecPtr = ^HFSCIRec;
  483.     HFSCIRec = RECORD
  484.         compInterfMask:            LONGINT;                                {  component flags  }
  485.         compInterfProc:            HFSCIProcPtr;                            {  pointer to file system call processing code  }
  486.         log2PhyProc:            Lg2PhysProcPtr;                            {  pointer to Lg2PhysProc() code  }
  487.         stackTop:                Ptr;                                    {  file system stack top  }
  488.         stackSize:                LONGINT;                                {  file system stack size  }
  489.         stackPtr:                Ptr;                                    {  current file system stack pointer  }
  490.         reserved3:                LONGINT;                                {  --reserved, must be zero--  }
  491.         idSector:                LONGINT;                                {  Sector you need to ID a local volume. For networked volumes, this must be -1  }
  492.         reserved2:                LONGINT;                                {  --reserved, must be zero--  }
  493.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  494.     END;
  495.  
  496. {
  497.  *    Disk Initialization Component Interface records
  498.  }
  499.     DICIProcPtr = ProcPtr;  { FUNCTION DICI(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr): OSErr; }
  500.  
  501.     DICIUPP = UniversalProcPtr;
  502.  
  503. CONST
  504.     uppDICIProcInfo = $00000FA0;
  505.  
  506. FUNCTION NewDICIProc(userRoutine: DICIProcPtr): DICIUPP;
  507.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  508.     INLINE $2E9F;
  509.     {$ENDC}
  510.  
  511. FUNCTION CallDICIProc(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; userRoutine: DICIUPP): OSErr;
  512.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  513.     INLINE $205F, $4E90;
  514.     {$ENDC}
  515.  
  516. TYPE
  517.     DICIRecPtr = ^DICIRec;
  518.     DICIRec = RECORD
  519.         compInterfMask:            LONGINT;                                {  component flags  }
  520.         compInterfProc:            DICIProcPtr;                            {  pointer to call processing code  }
  521.         maxVolNameLength:        INTEGER;                                {  maximum length of your volume name  }
  522.         blockSize:                INTEGER;                                {  your file system's block size  }
  523.         reserved3:                LONGINT;                                {  --reserved, must be zero--  }
  524.         reserved2:                LONGINT;                                {  --reserved, must be zero--  }
  525.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  526.     END;
  527.  
  528. {
  529.  * FormatListRec as returned by the .Sony disk driver's
  530.  * Return Format List status call (csCode = 6).
  531.  * If the status call to get this list for a drive is not
  532.  * implemented by the driver, then a list with one entry
  533.  * is contructed from the drive queue element for the drive.
  534.  }
  535.     FormatListRecPtr = ^FormatListRec;
  536.     FormatListRec = RECORD
  537.         volSize:                LONGINT;                                {  disk capacity in SECTORs  }
  538.         formatFlags:            SignedByte;                                {  flags  }
  539.         sectorsPerTrack:        SignedByte;                                {  sectors per track side  }
  540.         tracks:                    INTEGER;                                {  number of tracks  }
  541.     END;
  542.  
  543. {
  544.  * SizeListRec built from FormatListRecs as described above.
  545.  }
  546.     SizeListRecPtr = ^SizeListRec;
  547.     SizeListRec = RECORD
  548.         sizeListFlags:            INTEGER;                                {  flags as set by external file system  }
  549.         sizeEntry:                FormatListRec;                            {  disk driver format list record  }
  550.     END;
  551.  
  552. {
  553.  * paramBlock for the diCIEvaluateSize call
  554.  }
  555.     DICIEvaluateSizeRecPtr = ^DICIEvaluateSizeRec;
  556.     DICIEvaluateSizeRec = RECORD
  557.         defaultSizeIndex:        INTEGER;                                {  default size for this FS  }
  558.         numSizeEntries:            INTEGER;                                {  number of size entries  }
  559.         driveNumber:            INTEGER;                                {  drive number  }
  560.         sizeListPtr:            SizeListRecPtr;                            {  ptr to size entry table  }
  561.         sectorSize:                INTEGER;                                {  bytes per sector  }
  562.     END;
  563.  
  564. {
  565.  * paramBlock for the diCIExtendedZero call
  566.  }
  567.     DICIExtendedZeroRecPtr = ^DICIExtendedZeroRec;
  568.     DICIExtendedZeroRec = RECORD
  569.         driveNumber:            INTEGER;                                {  drive number  }
  570.         volNamePtr:                StringPtr;                                {  ptr to volume name string  }
  571.         fsid:                    INTEGER;                                {  file system ID  }
  572.         volTypeSelector:        INTEGER;                                {  volume type selector, if supports more than 1 type  }
  573.         numDefectBlocks:        INTEGER;                                {  number of bad logical blocks  }
  574.         defectListSize:            INTEGER;                                {  size of the defect list buffer in bytes  }
  575.         defectListPtr:            Ptr;                                    {  pointer to defect list buffer  }
  576.         volSize:                LONGINT;                                {  size of volume in SECTORs  }
  577.         sectorSize:                INTEGER;                                {  bytes per sector  }
  578.         extendedInfoPtr:        Ptr;                                    {  ptr to extended info  }
  579.     END;
  580.  
  581. {
  582.  * paramBlock for the diCIValidateVolName call
  583.  }
  584.     DICIValidateVolNameRecPtr = ^DICIValidateVolNameRec;
  585.     DICIValidateVolNameRec = PACKED RECORD
  586.         theChar:                CHAR;                                    {  the character to validate  }
  587.         hasMessageBuffer:        BOOLEAN;                                {  false if no message  }
  588.         charOffset:                INTEGER;                                {  position of the current character (first char = 1)  }
  589.         messageBufferPtr:        StringPtr;                                {  pointer to message buffer or nil  }
  590.         charByteType:            INTEGER;                                {  theChar's byte type (smSingleByte, smFirstByte, or smLastByte)  }
  591.     END;
  592.  
  593. {
  594.  * paramBlock for the diCIGetVolTypeInfo call
  595.  }
  596.     DICIGetVolTypeInfoRecPtr = ^DICIGetVolTypeInfoRec;
  597.     DICIGetVolTypeInfoRec = RECORD
  598.         volSize:                LONGINT;                                {  size of volume in SECTORs  }
  599.         sectorSize:                INTEGER;                                {  bytes per sector  }
  600.         numVolTypes:            INTEGER;                                {  number of volume types supported  }
  601.         volTypesBuffer:            ARRAY [0..3] OF Str31;                    {  4 string buffers  }
  602.     END;
  603.  
  604. {
  605.  * paramBlock for the diCIGetFormatString call
  606.  }
  607.     DICIGetFormatStringRecPtr = ^DICIGetFormatStringRec;
  608.     DICIGetFormatStringRec = RECORD
  609.         volSize:                LONGINT;                                {  volume size in SECTORs  }
  610.         sectorSize:                INTEGER;                                {  sector size  }
  611.         volTypeSelector:        INTEGER;                                {  volume type selector  }
  612.         stringKind:                INTEGER;                                {  sub-function = type of string  }
  613.         stringBuffer:            Str255;                                    {  string buffer  }
  614.     END;
  615.  
  616. {
  617.  * paramBlock for the diCIGetExtendedFormatParams call
  618.  }
  619.     DICIGetExtendedFormatRecPtr = ^DICIGetExtendedFormatRec;
  620.     DICIGetExtendedFormatRec = RECORD
  621.         driveNumber:            INTEGER;                                {  drive number  }
  622.         volTypeSelector:        INTEGER;                                {  volume type selector or 0  }
  623.         volSize:                LONGINT;                                {  size of volume in SECTORs  }
  624.         sectorSize:                INTEGER;                                {  bytes per sector  }
  625.         fileSystemSpecPtr:        FSSpecPtr;                                {  pointer to the foreign file system's FSSpec  }
  626.         extendedInfoPtr:        Ptr;                                    {  pointer to extended parameter structure  }
  627.     END;
  628.  
  629. {
  630.  *    File System Manager records
  631.  }
  632.  
  633.     FSDCommProcPtr = ProcPtr;  { FUNCTION FSDComm(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr): OSErr; }
  634.  
  635.     FSDCommUPP = UniversalProcPtr;
  636.  
  637. CONST
  638.     uppFSDCommProcInfo = $00000FA0;
  639.  
  640. FUNCTION NewFSDCommProc(userRoutine: FSDCommProcPtr): FSDCommUPP;
  641.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  642.     INLINE $2E9F;
  643.     {$ENDC}
  644.  
  645. FUNCTION CallFSDCommProc(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr; userRoutine: FSDCommUPP): OSErr;
  646.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  647.     INLINE $205F, $4E90;
  648.     {$ENDC}
  649.  
  650. TYPE
  651.     FSDRecPtr = ^FSDRec;
  652.     FSDRec = RECORD
  653.         fsdLink:                FSDRecPtr;                                {  ptr to next  }
  654.         fsdLength:                INTEGER;                                {  length of this FSD in BYTES  }
  655.         fsdVersion:                INTEGER;                                {  version number  }
  656.         fileSystemFSID:            INTEGER;                                {  file system id  }
  657.         fileSystemName:            Str31;                                    {  file system name  }
  658.         fileSystemSpec:            FSSpec;                                    {  foreign file system's FSSpec  }
  659.         fileSystemGlobalsPtr:    Ptr;                                    {  ptr to file system globals  }
  660.         fileSystemCommProc:        FSDCommProcPtr;                            {  communication proc with the FFS  }
  661.         reserved3:                LONGINT;                                {  --reserved, must be zero--  }
  662.         reserved2:                LONGINT;                                {  --reserved, must be zero--  }
  663.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  664.         fsdHFSCI:                HFSCIRec;                                {  HFS component interface     }
  665.         fsdDICI:                DICIRec;                                {  Disk Initialization component interface  }
  666.     END;
  667.  
  668.     FSMGetIconInfoRecPtr = ^FSMGetIconInfoRec;
  669.     FSMGetIconInfoRec = RECORD
  670.         theIcon:                ARRAY [0..31] OF LONGINT;                {  The ICN# structure  }
  671.         theMask:                ARRAY [0..31] OF LONGINT;                {  The mask for the icon above  }
  672.         whereStr:                Str255;
  673.     END;
  674.  
  675. {
  676.  * paramBlock for ffsGetIconMessage and fsmGetFSIconMessage
  677.  }
  678.     FSMGetIconRecPtr = ^FSMGetIconRec;
  679.     FSMGetIconRec = RECORD
  680.         refNum:                    INTEGER;                                {  target drive num or volume refnum  }
  681.         iconBufferPtr:            FSMGetIconInfoRecPtr;                    {  pointer to icon buffer  }
  682.         requestSize:            LONGINT;                                {  requested size of the icon buffer  }
  683.         actualSize:                LONGINT;                                {  actual size of the icon data returned  }
  684.         iconType:                SInt8;                                    {  kind of icon  }
  685.         isEjectable:            BOOLEAN;                                {  true if the device is ejectable  }
  686.         driveQElemPtr:            DrvQElPtr;                                {  pointer to DQE  }
  687.         fileSystemSpecPtr:        FSSpecPtr;                                {  pointer to foreign file system's FSSpec  }
  688.         reserved1:                LONGINT;                                {  --reserved, must be zero--  }
  689.     END;
  690.  
  691. {
  692.  *    HFS Utility routine prototypes
  693.  }
  694. FUNCTION UTAllocateFCB(VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  695.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  696.     INLINE $7000, $A824;
  697.     {$ENDC}
  698. FUNCTION UTReleaseFCB(fileRefNum: INTEGER): OSErr;
  699.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  700.     INLINE $7001, $A824;
  701.     {$ENDC}
  702. FUNCTION UTLocateFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  703.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  704.     INLINE $7002, $A824;
  705.     {$ENDC}
  706. FUNCTION UTLocateNextFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  707.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  708.     INLINE $7003, $A824;
  709.     {$ENDC}
  710. FUNCTION UTIndexFCB(volCtrlBlockPtr: VCBPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  711.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  712.     INLINE $7004, $A824;
  713.     {$ENDC}
  714. FUNCTION UTResolveFCB(fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  715.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  716.     INLINE $7005, $A824;
  717.     {$ENDC}
  718. FUNCTION UTAllocateVCB(VAR sysVCBLength: INTEGER; VAR volCtrlBlockPtr: VCBPtr; addSize: INTEGER): OSErr;
  719.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  720.     INLINE $7006, $A824;
  721.     {$ENDC}
  722. FUNCTION UTAddNewVCB(driveNum: INTEGER; VAR vRefNum: INTEGER; volCtrlBlockPtr: VCBPtr): OSErr;
  723.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  724.     INLINE $7007, $A824;
  725.     {$ENDC}
  726. FUNCTION UTDisposeVCB(volCtrlBlockPtr: VCBPtr): OSErr;
  727.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  728.     INLINE $7008, $A824;
  729.     {$ENDC}
  730. FUNCTION UTLocateVCBByRefNum(refNum: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  731.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  732.     INLINE $7009, $A824;
  733.     {$ENDC}
  734. FUNCTION UTLocateVCBByName(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  735.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  736.     INLINE $700A, $A824;
  737.     {$ENDC}
  738. FUNCTION UTLocateNextVCB(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  739.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  740.     INLINE $700B, $A824;
  741.     {$ENDC}
  742. FUNCTION UTAllocateWDCB(paramBlock: WDPBPtr): OSErr;
  743.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  744.     INLINE $700C, $A824;
  745.     {$ENDC}
  746. FUNCTION UTReleaseWDCB(wdRefNum: INTEGER): OSErr;
  747.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  748.     INLINE $700D, $A824;
  749.     {$ENDC}
  750. FUNCTION UTResolveWDCB(procID: LONGINT; wdIndex: INTEGER; wdRefNum: INTEGER; VAR wdCtrlBlockPtr: WDCBRecPtr): OSErr;
  751.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  752.     INLINE $700E, $A824;
  753.     {$ENDC}
  754. FUNCTION UTFindDrive(driveNum: INTEGER; VAR driveQElementPtr: DrvQElPtr): OSErr;
  755.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  756.     INLINE $700F, $A824;
  757.     {$ENDC}
  758. FUNCTION UTAdjustEOF(fileRefNum: INTEGER): OSErr;
  759.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  760.     INLINE $7010, $A824;
  761.     {$ENDC}
  762. FUNCTION UTSetDefaultVol(nodeHint: LONGINT; dirID: LONGINT; refNum: INTEGER): OSErr;
  763.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  764.     INLINE $7011, $A824;
  765.     {$ENDC}
  766. FUNCTION UTGetDefaultVol(paramBlock: WDPBPtr): OSErr;
  767.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  768.     INLINE $7012, $A824;
  769.     {$ENDC}
  770. FUNCTION UTEjectVol(volCtrlBlockPtr: VCBPtr): OSErr;
  771.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  772.     INLINE $702B, $A824;
  773.     {$ENDC}
  774. FUNCTION UTCheckWDRefNum(wdRefNum: INTEGER): OSErr;
  775.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  776.     INLINE $7013, $A824;
  777.     {$ENDC}
  778. FUNCTION UTCheckFileRefNum(fileRefNum: INTEGER): OSErr;
  779.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  780.     INLINE $7014, $A824;
  781.     {$ENDC}
  782. FUNCTION UTCheckVolRefNum(vRefNum: INTEGER): OSErr;
  783.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  784.     INLINE $7015, $A824;
  785.     {$ENDC}
  786. FUNCTION UTCheckPermission(volCtrlBlockPtr: VCBPtr; VAR modByte: INTEGER; fileNum: LONGINT; paramBlock: ParmBlkPtr): OSErr;
  787.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  788.     INLINE $7016, $A824;
  789.     {$ENDC}
  790. FUNCTION UTCheckVolOffline(vRefNum: INTEGER): OSErr;
  791.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  792.     INLINE $7017, $A824;
  793.     {$ENDC}
  794. FUNCTION UTCheckVolModifiable(vRefNum: INTEGER): OSErr;
  795.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  796.     INLINE $7018, $A824;
  797.     {$ENDC}
  798. FUNCTION UTCheckFileModifiable(fileRefNum: INTEGER): OSErr;
  799.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  800.     INLINE $7019, $A824;
  801.     {$ENDC}
  802. FUNCTION UTCheckDirBusy(volCtrlBlockPtr: VCBPtr; dirID: LONGINT): OSErr;
  803.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  804.     INLINE $701A, $A824;
  805.     {$ENDC}
  806. FUNCTION UTParsePathname(VAR volNamelength: INTEGER; namePtr: StringPtr): OSErr;
  807.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  808.     INLINE $701B, $A824;
  809.     {$ENDC}
  810. FUNCTION UTGetPathComponentName(parseRec: ParsePathRecPtr): OSErr;
  811.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  812.     INLINE $701C, $A824;
  813.     {$ENDC}
  814. FUNCTION UTDetermineVol(paramBlock: ParmBlkPtr; VAR status: INTEGER; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  815.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  816.     INLINE $701D, $A824;
  817.     {$ENDC}
  818. FUNCTION UTGetBlock(refNum: INTEGER; log2PhyProc: UNIV Ptr; blockNum: LONGINT; gbOption: INTEGER; VAR buffer: Ptr): OSErr;
  819.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  820.     INLINE $701F, $A824;
  821.     {$ENDC}
  822. FUNCTION UTReleaseBlock(buffer: Ptr; rbOption: INTEGER): OSErr;
  823.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  824.     INLINE $7020, $A824;
  825.     {$ENDC}
  826. FUNCTION UTFlushCache(refNum: INTEGER; fcOption: INTEGER): OSErr;
  827.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  828.     INLINE $7021, $A824;
  829.     {$ENDC}
  830. FUNCTION UTMarkDirty(buffer: Ptr): OSErr;
  831.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  832.     INLINE $7023, $A824;
  833.     {$ENDC}
  834. FUNCTION UTTrashVolBlocks(volCtrlBlockPtr: VCBPtr): OSErr;
  835.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  836.     INLINE $7024, $A824;
  837.     {$ENDC}
  838. FUNCTION UTTrashFileBlocks(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT): OSErr;
  839.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  840.     INLINE $7025, $A824;
  841.     {$ENDC}
  842. FUNCTION UTTrashBlocks(beginPosition: LONGINT; byteCount: LONGINT; volCtrlBlockPtr: VCBPtr; fileRefNum: INTEGER; tbOption: INTEGER): OSErr;
  843.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  844.     INLINE $7026, $A824;
  845.     {$ENDC}
  846. FUNCTION UTCacheReadIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  847.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  848.     INLINE $7027, $A824;
  849.     {$ENDC}
  850. FUNCTION UTCacheWriteIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  851.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  852.     INLINE $7028, $A824;
  853.     {$ENDC}
  854. FUNCTION UTBlockInFQHashP(vRefNum: INTEGER; diskBlock: LONGINT): OSErr;
  855.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  856.     INLINE $702C, $A824;
  857.     {$ENDC}
  858. FUNCTION UTVolCacheReadIP(volCtrlBlockPtr: VCBPtr; blockPosition: LONGINT; ioBuffer: Ptr; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  859.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  860.     INLINE $7034, $A824;
  861.     {$ENDC}
  862. FUNCTION UTVolCacheWriteIP(volCtrlBlockPtr: VCBPtr; blockPosition: LONGINT; ioBuffer: Ptr; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  863.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  864.     INLINE $7035, $A824;
  865.     {$ENDC}
  866.  
  867.  
  868. {
  869.  *    File System Manager call prototypes
  870.  }
  871. FUNCTION InstallFS(fsdPtr: FSDRecPtr): OSErr;
  872. FUNCTION RemoveFS(fsid: INTEGER): OSErr;
  873. FUNCTION SetFSInfo(fsid: INTEGER; bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  874. FUNCTION GetFSInfo(selector: INTEGER; key: INTEGER; VAR bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  875. FUNCTION InformFSM(theMessage: INTEGER; paramBlock: UNIV Ptr): OSErr;
  876. FUNCTION InformFFS(fsid: INTEGER; paramBlock: UNIV Ptr): OSErr;
  877.  
  878.  
  879. {$ALIGN RESET}
  880. {$POP}
  881.  
  882. {$SETC UsingIncludes := FSMIncludes}
  883.  
  884. {$ENDC} {__FSM__}
  885.  
  886. {$IFC NOT UsingIncludes}
  887.  END.
  888. {$ENDC}
  889.